// $ANTLR 3.4 /Users/iamapo/Downloads/CI Praktikum 1/CIPAUFGABE1Abgenommen.g 2013-11-10 20:18:20

import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;

import org.antlr.runtime.debug.*;
import java.io.IOException;
import org.antlr.runtime.tree.*;


@SuppressWarnings({"all", "warnings", "unchecked"})
public class CIPAUFGABE1AbgenommenParser extends DebugParser {
    public static final String[] tokenNames = new String[] {
        "<invalid>", "<EOR>", "<DOWN>", "<UP>", "Equ", "Num", "Op", "RAETSEL"
    };

    public static final int EOF=-1;
    public static final int Equ=4;
    public static final int Num=5;
    public static final int Op=6;
    public static final int RAETSEL=7;

    // delegates
    public Parser[] getDelegates() {
        return new Parser[] {};
    }

    // delegators


public static final String[] ruleNames = new String[] {
    "invalidRule", "program", "num", "op", "tripleequal", "expression", 
    "equ", "tripleop"
};

public static final boolean[] decisionCanBacktrack = new boolean[] {
    false, // invalid decision
    false
};

 
    public int ruleLevel = 0;
    public int getRuleLevel() { return ruleLevel; }
    public void incRuleLevel() { ruleLevel++; }
    public void decRuleLevel() { ruleLevel--; }
    public CIPAUFGABE1AbgenommenParser(TokenStream input) {
        this(input, DebugEventSocketProxy.DEFAULT_DEBUGGER_PORT, new RecognizerSharedState());
    }
    public CIPAUFGABE1AbgenommenParser(TokenStream input, int port, RecognizerSharedState state) {
        super(input, state);
        DebugEventSocketProxy proxy =
            new DebugEventSocketProxy(this,port,adaptor);
        setDebugListener(proxy);
        setTokenStream(new DebugTokenStream(input,proxy));
        try {
            proxy.handshake();
        }
        catch (IOException ioe) {
            reportError(ioe);
        }
        TreeAdaptor adap = new CommonTreeAdaptor();
        setTreeAdaptor(adap);
        proxy.setTreeAdaptor(adap);
    }

public CIPAUFGABE1AbgenommenParser(TokenStream input, DebugEventListener dbg) {
    super(input, dbg);
     
    TreeAdaptor adap = new CommonTreeAdaptor();
    setTreeAdaptor(adap);


}

protected boolean evalPredicate(boolean result, String predicate) {
    dbg.semanticPredicate(result, predicate);
    return result;
}

protected DebugTreeAdaptor adaptor;
public void setTreeAdaptor(TreeAdaptor adaptor) {
    this.adaptor = new DebugTreeAdaptor(dbg,adaptor);


}
public TreeAdaptor getTreeAdaptor() {
    return adaptor;
}

    public String[] getTokenNames() { return CIPAUFGABE1AbgenommenParser.tokenNames; }
    public String getGrammarFileName() { return "/Users/iamapo/Downloads/CI Praktikum 1/CIPAUFGABE1Abgenommen.g"; }


    public static class program_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "program"
    // /Users/iamapo/Downloads/CI Praktikum 1/CIPAUFGABE1Abgenommen.g:11:1: program : (a1= num o1= op a2= num e1= equ a3= num o2= op o3= op o4= op a4= num o5= op a5= num e2= equ a6= num e3= equ e4= equ e5= equ a7= num o6= op a8= num e6= equ a9= num ) ;
    public final CIPAUFGABE1AbgenommenParser.program_return program() throws RecognitionException {
        CIPAUFGABE1AbgenommenParser.program_return retval = new CIPAUFGABE1AbgenommenParser.program_return();
        retval.start = input.LT(1);


        CommonTree root_0 = null;

        CIPAUFGABE1AbgenommenParser.num_return a1 =null;

        CIPAUFGABE1AbgenommenParser.op_return o1 =null;

        CIPAUFGABE1AbgenommenParser.num_return a2 =null;

        CIPAUFGABE1AbgenommenParser.equ_return e1 =null;

        CIPAUFGABE1AbgenommenParser.num_return a3 =null;

        CIPAUFGABE1AbgenommenParser.op_return o2 =null;

        CIPAUFGABE1AbgenommenParser.op_return o3 =null;

        CIPAUFGABE1AbgenommenParser.op_return o4 =null;

        CIPAUFGABE1AbgenommenParser.num_return a4 =null;

        CIPAUFGABE1AbgenommenParser.op_return o5 =null;

        CIPAUFGABE1AbgenommenParser.num_return a5 =null;

        CIPAUFGABE1AbgenommenParser.equ_return e2 =null;

        CIPAUFGABE1AbgenommenParser.num_return a6 =null;

        CIPAUFGABE1AbgenommenParser.equ_return e3 =null;

        CIPAUFGABE1AbgenommenParser.equ_return e4 =null;

        CIPAUFGABE1AbgenommenParser.equ_return e5 =null;

        CIPAUFGABE1AbgenommenParser.num_return a7 =null;

        CIPAUFGABE1AbgenommenParser.op_return o6 =null;

        CIPAUFGABE1AbgenommenParser.num_return a8 =null;

        CIPAUFGABE1AbgenommenParser.equ_return e6 =null;

        CIPAUFGABE1AbgenommenParser.num_return a9 =null;



        try { dbg.enterRule(getGrammarFileName(), "program");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(11, 0);

        try {
            // /Users/iamapo/Downloads/CI Praktikum 1/CIPAUFGABE1Abgenommen.g:11:8: ( (a1= num o1= op a2= num e1= equ a3= num o2= op o3= op o4= op a4= num o5= op a5= num e2= equ a6= num e3= equ e4= equ e5= equ a7= num o6= op a8= num e6= equ a9= num ) )
            dbg.enterAlt(1);

            // /Users/iamapo/Downloads/CI Praktikum 1/CIPAUFGABE1Abgenommen.g:11:12: (a1= num o1= op a2= num e1= equ a3= num o2= op o3= op o4= op a4= num o5= op a5= num e2= equ a6= num e3= equ e4= equ e5= equ a7= num o6= op a8= num e6= equ a9= num )
            {
            root_0 = (CommonTree)adaptor.nil();


            dbg.location(11,12);
            // /Users/iamapo/Downloads/CI Praktikum 1/CIPAUFGABE1Abgenommen.g:11:12: (a1= num o1= op a2= num e1= equ a3= num o2= op o3= op o4= op a4= num o5= op a5= num e2= equ a6= num e3= equ e4= equ e5= equ a7= num o6= op a8= num e6= equ a9= num )
            dbg.enterAlt(1);

            // /Users/iamapo/Downloads/CI Praktikum 1/CIPAUFGABE1Abgenommen.g:11:14: a1= num o1= op a2= num e1= equ a3= num o2= op o3= op o4= op a4= num o5= op a5= num e2= equ a6= num e3= equ e4= equ e5= equ a7= num o6= op a8= num e6= equ a9= num
            {
            dbg.location(11,16);
            pushFollow(FOLLOW_num_in_program41);
            a1=num();

            state._fsp--;

            adaptor.addChild(root_0, a1.getTree());
            dbg.location(11,23);
            pushFollow(FOLLOW_op_in_program45);
            o1=op();

            state._fsp--;

            adaptor.addChild(root_0, o1.getTree());
            dbg.location(11,29);
            pushFollow(FOLLOW_num_in_program49);
            a2=num();

            state._fsp--;

            adaptor.addChild(root_0, a2.getTree());
            dbg.location(11,36);
            pushFollow(FOLLOW_equ_in_program53);
            e1=equ();

            state._fsp--;

            adaptor.addChild(root_0, e1.getTree());
            dbg.location(11,43);
            pushFollow(FOLLOW_num_in_program57);
            a3=num();

            state._fsp--;

            adaptor.addChild(root_0, a3.getTree());
            dbg.location(12,8);
            pushFollow(FOLLOW_op_in_program66);
            o2=op();

            state._fsp--;

            adaptor.addChild(root_0, o2.getTree());
            dbg.location(12,14);
            pushFollow(FOLLOW_op_in_program70);
            o3=op();

            state._fsp--;

            adaptor.addChild(root_0, o3.getTree());
            dbg.location(12,20);
            pushFollow(FOLLOW_op_in_program74);
            o4=op();

            state._fsp--;

            adaptor.addChild(root_0, o4.getTree());
            dbg.location(13,8);
            pushFollow(FOLLOW_num_in_program83);
            a4=num();

            state._fsp--;

            adaptor.addChild(root_0, a4.getTree());
            dbg.location(13,15);
            pushFollow(FOLLOW_op_in_program87);
            o5=op();

            state._fsp--;

            adaptor.addChild(root_0, o5.getTree());
            dbg.location(13,21);
            pushFollow(FOLLOW_num_in_program91);
            a5=num();

            state._fsp--;

            adaptor.addChild(root_0, a5.getTree());
            dbg.location(13,28);
            pushFollow(FOLLOW_equ_in_program95);
            e2=equ();

            state._fsp--;

            adaptor.addChild(root_0, e2.getTree());
            dbg.location(13,35);
            pushFollow(FOLLOW_num_in_program99);
            a6=num();

            state._fsp--;

            adaptor.addChild(root_0, a6.getTree());
            dbg.location(14,8);
            pushFollow(FOLLOW_equ_in_program108);
            e3=equ();

            state._fsp--;

            adaptor.addChild(root_0, e3.getTree());
            dbg.location(14,15);
            pushFollow(FOLLOW_equ_in_program112);
            e4=equ();

            state._fsp--;

            adaptor.addChild(root_0, e4.getTree());
            dbg.location(14,22);
            pushFollow(FOLLOW_equ_in_program116);
            e5=equ();

            state._fsp--;

            adaptor.addChild(root_0, e5.getTree());
            dbg.location(15,8);
            pushFollow(FOLLOW_num_in_program125);
            a7=num();

            state._fsp--;

            adaptor.addChild(root_0, a7.getTree());
            dbg.location(15,15);
            pushFollow(FOLLOW_op_in_program129);
            o6=op();

            state._fsp--;

            adaptor.addChild(root_0, o6.getTree());
            dbg.location(15,21);
            pushFollow(FOLLOW_num_in_program133);
            a8=num();

            state._fsp--;

            adaptor.addChild(root_0, a8.getTree());
            dbg.location(15,28);
            pushFollow(FOLLOW_equ_in_program137);
            e6=equ();

            state._fsp--;

            adaptor.addChild(root_0, e6.getTree());
            dbg.location(15,35);
            pushFollow(FOLLOW_num_in_program141);
            a9=num();

            state._fsp--;

            adaptor.addChild(root_0, a9.getTree());

            }


            }

            retval.stop = input.LT(-1);


            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        dbg.location(16, 5);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "program");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "program"


    public static class expression_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "expression"
    // /Users/iamapo/Downloads/CI Praktikum 1/CIPAUFGABE1Abgenommen.g:17:1: expression : num Op num Equ num ;
    public final CIPAUFGABE1AbgenommenParser.expression_return expression() throws RecognitionException {
        CIPAUFGABE1AbgenommenParser.expression_return retval = new CIPAUFGABE1AbgenommenParser.expression_return();
        retval.start = input.LT(1);


        CommonTree root_0 = null;

        Token Op2=null;
        Token Equ4=null;
        CIPAUFGABE1AbgenommenParser.num_return num1 =null;

        CIPAUFGABE1AbgenommenParser.num_return num3 =null;

        CIPAUFGABE1AbgenommenParser.num_return num5 =null;


        CommonTree Op2_tree=null;
        CommonTree Equ4_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "expression");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(17, 0);

        try {
            // /Users/iamapo/Downloads/CI Praktikum 1/CIPAUFGABE1Abgenommen.g:17:12: ( num Op num Equ num )
            dbg.enterAlt(1);

            // /Users/iamapo/Downloads/CI Praktikum 1/CIPAUFGABE1Abgenommen.g:17:13: num Op num Equ num
            {
            root_0 = (CommonTree)adaptor.nil();


            dbg.location(17,13);
            pushFollow(FOLLOW_num_in_expression154);
            num1=num();

            state._fsp--;

            adaptor.addChild(root_0, num1.getTree());
            dbg.location(17,18);
            Op2=(Token)match(input,Op,FOLLOW_Op_in_expression157); 
            Op2_tree = 
            (CommonTree)adaptor.create(Op2)
            ;
            adaptor.addChild(root_0, Op2_tree);

            dbg.location(17,22);
            pushFollow(FOLLOW_num_in_expression160);
            num3=num();

            state._fsp--;

            adaptor.addChild(root_0, num3.getTree());
            dbg.location(17,27);
            Equ4=(Token)match(input,Equ,FOLLOW_Equ_in_expression163); 
            Equ4_tree = 
            (CommonTree)adaptor.create(Equ4)
            ;
            adaptor.addChild(root_0, Equ4_tree);

            dbg.location(17,32);
            pushFollow(FOLLOW_num_in_expression166);
            num5=num();

            state._fsp--;

            adaptor.addChild(root_0, num5.getTree());

            }

            retval.stop = input.LT(-1);


            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        dbg.location(19, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "expression");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "expression"


    public static class op_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "op"
    // /Users/iamapo/Downloads/CI Praktikum 1/CIPAUFGABE1Abgenommen.g:20:1: op : Op ;
    public final CIPAUFGABE1AbgenommenParser.op_return op() throws RecognitionException {
        CIPAUFGABE1AbgenommenParser.op_return retval = new CIPAUFGABE1AbgenommenParser.op_return();
        retval.start = input.LT(1);


        CommonTree root_0 = null;

        Token Op6=null;

        CommonTree Op6_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "op");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(20, 0);

        try {
            // /Users/iamapo/Downloads/CI Praktikum 1/CIPAUFGABE1Abgenommen.g:20:5: ( Op )
            dbg.enterAlt(1);

            // /Users/iamapo/Downloads/CI Praktikum 1/CIPAUFGABE1Abgenommen.g:20:7: Op
            {
            root_0 = (CommonTree)adaptor.nil();


            dbg.location(20,7);
            Op6=(Token)match(input,Op,FOLLOW_Op_in_op178); 
            Op6_tree = 
            (CommonTree)adaptor.create(Op6)
            ;
            adaptor.addChild(root_0, Op6_tree);


            }

            retval.stop = input.LT(-1);


            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        dbg.location(20, 8);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "op");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "op"


    public static class equ_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "equ"
    // /Users/iamapo/Downloads/CI Praktikum 1/CIPAUFGABE1Abgenommen.g:21:1: equ : Equ ;
    public final CIPAUFGABE1AbgenommenParser.equ_return equ() throws RecognitionException {
        CIPAUFGABE1AbgenommenParser.equ_return retval = new CIPAUFGABE1AbgenommenParser.equ_return();
        retval.start = input.LT(1);


        CommonTree root_0 = null;

        Token Equ7=null;

        CommonTree Equ7_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "equ");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(21, 0);

        try {
            // /Users/iamapo/Downloads/CI Praktikum 1/CIPAUFGABE1Abgenommen.g:22:2: ( Equ )
            dbg.enterAlt(1);

            // /Users/iamapo/Downloads/CI Praktikum 1/CIPAUFGABE1Abgenommen.g:22:5: Equ
            {
            root_0 = (CommonTree)adaptor.nil();


            dbg.location(22,5);
            Equ7=(Token)match(input,Equ,FOLLOW_Equ_in_equ198); 
            Equ7_tree = 
            (CommonTree)adaptor.create(Equ7)
            ;
            adaptor.addChild(root_0, Equ7_tree);


            }

            retval.stop = input.LT(-1);


            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        dbg.location(22, 7);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "equ");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "equ"


    public static class num_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "num"
    // /Users/iamapo/Downloads/CI Praktikum 1/CIPAUFGABE1Abgenommen.g:23:1: num : ( Num )* ;
    public final CIPAUFGABE1AbgenommenParser.num_return num() throws RecognitionException {
        CIPAUFGABE1AbgenommenParser.num_return retval = new CIPAUFGABE1AbgenommenParser.num_return();
        retval.start = input.LT(1);


        CommonTree root_0 = null;

        Token Num8=null;

        CommonTree Num8_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "num");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(23, 0);

        try {
            // /Users/iamapo/Downloads/CI Praktikum 1/CIPAUFGABE1Abgenommen.g:23:6: ( ( Num )* )
            dbg.enterAlt(1);

            // /Users/iamapo/Downloads/CI Praktikum 1/CIPAUFGABE1Abgenommen.g:23:7: ( Num )*
            {
            root_0 = (CommonTree)adaptor.nil();


            dbg.location(23,7);
            // /Users/iamapo/Downloads/CI Praktikum 1/CIPAUFGABE1Abgenommen.g:23:7: ( Num )*
            try { dbg.enterSubRule(1);

            loop1:
            do {
                int alt1=2;
                try { dbg.enterDecision(1, decisionCanBacktrack[1]);

                int LA1_0 = input.LA(1);

                if ( (LA1_0==Num) ) {
                    alt1=1;
                }


                } finally {dbg.exitDecision(1);}

                switch (alt1) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // /Users/iamapo/Downloads/CI Praktikum 1/CIPAUFGABE1Abgenommen.g:23:8: Num
            	    {
            	    dbg.location(23,8);
            	    Num8=(Token)match(input,Num,FOLLOW_Num_in_num207); 
            	    Num8_tree = 
            	    (CommonTree)adaptor.create(Num8)
            	    ;
            	    adaptor.addChild(root_0, Num8_tree);


            	    }
            	    break;

            	default :
            	    break loop1;
                }
            } while (true);
            } finally {dbg.exitSubRule(1);}


            }

            retval.stop = input.LT(-1);


            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        dbg.location(24, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "num");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "num"


    public static class tripleequal_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "tripleequal"
    // /Users/iamapo/Downloads/CI Praktikum 1/CIPAUFGABE1Abgenommen.g:25:1: tripleequal : Equ Equ Equ ;
    public final CIPAUFGABE1AbgenommenParser.tripleequal_return tripleequal() throws RecognitionException {
        CIPAUFGABE1AbgenommenParser.tripleequal_return retval = new CIPAUFGABE1AbgenommenParser.tripleequal_return();
        retval.start = input.LT(1);


        CommonTree root_0 = null;

        Token Equ9=null;
        Token Equ10=null;
        Token Equ11=null;

        CommonTree Equ9_tree=null;
        CommonTree Equ10_tree=null;
        CommonTree Equ11_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "tripleequal");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(25, 0);

        try {
            // /Users/iamapo/Downloads/CI Praktikum 1/CIPAUFGABE1Abgenommen.g:25:13: ( Equ Equ Equ )
            dbg.enterAlt(1);

            // /Users/iamapo/Downloads/CI Praktikum 1/CIPAUFGABE1Abgenommen.g:25:14: Equ Equ Equ
            {
            root_0 = (CommonTree)adaptor.nil();


            dbg.location(25,14);
            Equ9=(Token)match(input,Equ,FOLLOW_Equ_in_tripleequal219); 
            Equ9_tree = 
            (CommonTree)adaptor.create(Equ9)
            ;
            adaptor.addChild(root_0, Equ9_tree);

            dbg.location(25,19);
            Equ10=(Token)match(input,Equ,FOLLOW_Equ_in_tripleequal222); 
            Equ10_tree = 
            (CommonTree)adaptor.create(Equ10)
            ;
            adaptor.addChild(root_0, Equ10_tree);

            dbg.location(25,24);
            Equ11=(Token)match(input,Equ,FOLLOW_Equ_in_tripleequal225); 
            Equ11_tree = 
            (CommonTree)adaptor.create(Equ11)
            ;
            adaptor.addChild(root_0, Equ11_tree);


            }

            retval.stop = input.LT(-1);


            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        dbg.location(26, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "tripleequal");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "tripleequal"


    public static class tripleop_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "tripleop"
    // /Users/iamapo/Downloads/CI Praktikum 1/CIPAUFGABE1Abgenommen.g:27:1: tripleop : Op Op Op ;
    public final CIPAUFGABE1AbgenommenParser.tripleop_return tripleop() throws RecognitionException {
        CIPAUFGABE1AbgenommenParser.tripleop_return retval = new CIPAUFGABE1AbgenommenParser.tripleop_return();
        retval.start = input.LT(1);


        CommonTree root_0 = null;

        Token Op12=null;
        Token Op13=null;
        Token Op14=null;

        CommonTree Op12_tree=null;
        CommonTree Op13_tree=null;
        CommonTree Op14_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "tripleop");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(27, 0);

        try {
            // /Users/iamapo/Downloads/CI Praktikum 1/CIPAUFGABE1Abgenommen.g:27:10: ( Op Op Op )
            dbg.enterAlt(1);

            // /Users/iamapo/Downloads/CI Praktikum 1/CIPAUFGABE1Abgenommen.g:27:12: Op Op Op
            {
            root_0 = (CommonTree)adaptor.nil();


            dbg.location(27,12);
            Op12=(Token)match(input,Op,FOLLOW_Op_in_tripleop237); 
            Op12_tree = 
            (CommonTree)adaptor.create(Op12)
            ;
            adaptor.addChild(root_0, Op12_tree);

            dbg.location(27,15);
            Op13=(Token)match(input,Op,FOLLOW_Op_in_tripleop239); 
            Op13_tree = 
            (CommonTree)adaptor.create(Op13)
            ;
            adaptor.addChild(root_0, Op13_tree);

            dbg.location(27,18);
            Op14=(Token)match(input,Op,FOLLOW_Op_in_tripleop241); 
            Op14_tree = 
            (CommonTree)adaptor.create(Op14)
            ;
            adaptor.addChild(root_0, Op14_tree);


            }

            retval.stop = input.LT(-1);


            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        dbg.location(28, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "tripleop");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "tripleop"

    // Delegated rules


 

    public static final BitSet FOLLOW_num_in_program41 = new BitSet(new long[]{0x0000000000000040L});
    public static final BitSet FOLLOW_op_in_program45 = new BitSet(new long[]{0x0000000000000030L});
    public static final BitSet FOLLOW_num_in_program49 = new BitSet(new long[]{0x0000000000000010L});
    public static final BitSet FOLLOW_equ_in_program53 = new BitSet(new long[]{0x0000000000000060L});
    public static final BitSet FOLLOW_num_in_program57 = new BitSet(new long[]{0x0000000000000040L});
    public static final BitSet FOLLOW_op_in_program66 = new BitSet(new long[]{0x0000000000000040L});
    public static final BitSet FOLLOW_op_in_program70 = new BitSet(new long[]{0x0000000000000040L});
    public static final BitSet FOLLOW_op_in_program74 = new BitSet(new long[]{0x0000000000000060L});
    public static final BitSet FOLLOW_num_in_program83 = new BitSet(new long[]{0x0000000000000040L});
    public static final BitSet FOLLOW_op_in_program87 = new BitSet(new long[]{0x0000000000000030L});
    public static final BitSet FOLLOW_num_in_program91 = new BitSet(new long[]{0x0000000000000010L});
    public static final BitSet FOLLOW_equ_in_program95 = new BitSet(new long[]{0x0000000000000030L});
    public static final BitSet FOLLOW_num_in_program99 = new BitSet(new long[]{0x0000000000000010L});
    public static final BitSet FOLLOW_equ_in_program108 = new BitSet(new long[]{0x0000000000000010L});
    public static final BitSet FOLLOW_equ_in_program112 = new BitSet(new long[]{0x0000000000000010L});
    public static final BitSet FOLLOW_equ_in_program116 = new BitSet(new long[]{0x0000000000000060L});
    public static final BitSet FOLLOW_num_in_program125 = new BitSet(new long[]{0x0000000000000040L});
    public static final BitSet FOLLOW_op_in_program129 = new BitSet(new long[]{0x0000000000000030L});
    public static final BitSet FOLLOW_num_in_program133 = new BitSet(new long[]{0x0000000000000010L});
    public static final BitSet FOLLOW_equ_in_program137 = new BitSet(new long[]{0x0000000000000020L});
    public static final BitSet FOLLOW_num_in_program141 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_num_in_expression154 = new BitSet(new long[]{0x0000000000000040L});
    public static final BitSet FOLLOW_Op_in_expression157 = new BitSet(new long[]{0x0000000000000030L});
    public static final BitSet FOLLOW_num_in_expression160 = new BitSet(new long[]{0x0000000000000010L});
    public static final BitSet FOLLOW_Equ_in_expression163 = new BitSet(new long[]{0x0000000000000020L});
    public static final BitSet FOLLOW_num_in_expression166 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_Op_in_op178 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_Equ_in_equ198 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_Num_in_num207 = new BitSet(new long[]{0x0000000000000022L});
    public static final BitSet FOLLOW_Equ_in_tripleequal219 = new BitSet(new long[]{0x0000000000000010L});
    public static final BitSet FOLLOW_Equ_in_tripleequal222 = new BitSet(new long[]{0x0000000000000010L});
    public static final BitSet FOLLOW_Equ_in_tripleequal225 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_Op_in_tripleop237 = new BitSet(new long[]{0x0000000000000040L});
    public static final BitSet FOLLOW_Op_in_tripleop239 = new BitSet(new long[]{0x0000000000000040L});
    public static final BitSet FOLLOW_Op_in_tripleop241 = new BitSet(new long[]{0x0000000000000002L});

}